home *** CD-ROM | disk | FTP | other *** search
/ CU Amiga Super CD-ROM 15 / CU Amiga Magazine's Super CD-ROM 15 (1997)(EMAP Images)(GB)[!][issue 1997-10].iso / CUCD / Graphics / Ghostscript / source / gs_res.ps < prev    next >
Encoding:
Text File  |  1997-06-18  |  18.0 KB  |  648 lines
  1. %    Copyright (C) 1994, 1996, 1997 Aladdin Enterprises.  All rights reserved.
  2. % 
  3. % This file is part of Aladdin Ghostscript.
  4. % 
  5. % Aladdin Ghostscript is distributed with NO WARRANTY OF ANY KIND.  No author
  6. % or distributor accepts any responsibility for the consequences of using it,
  7. % or for whether it serves any particular purpose or works at all, unless he
  8. % or she says so in writing.  Refer to the Aladdin Ghostscript Free Public
  9. % License (the "License") for full details.
  10. % 
  11. % Every copy of Aladdin Ghostscript must include a copy of the License,
  12. % normally in a plain ASCII text file named PUBLIC.  The License grants you
  13. % the right to copy, modify and redistribute Aladdin Ghostscript, but only
  14. % under certain conditions described in the License.  Among other things, the
  15. % License requires that the copyright notice and this notice be preserved on
  16. % all copies.
  17.  
  18. % Initialization file for Level 2 resource machinery.
  19. % When this is run, systemdict is still writable,
  20. % but (almost) everything defined here goes into level2dict.
  21.  
  22. level2dict begin
  23.  
  24. (BEGIN RESOURCES) VMDEBUG
  25.  
  26. % We keep track of (global) instances with another entry in the resource
  27. % dictionary, an Instances dictionary.  For categories with implicit
  28. % instances, the values in Instances are the same as the keys;
  29. % for other categories, the values are [instance status size].
  30.  
  31. % Note that the dictionary that defines a resource category is stored
  32. % in global memory.  The PostScript manual says that each category must
  33. % manage global and local instances separately.  However, objects in
  34. % global memory other than systemdict can't reference objects in local memory.
  35. % This means that the resource category dictionary, which would otherwise be
  36. % the obvious place to keep track of the instances, can't be used to keep
  37. % track of local instances.  Instead, we define a dictionary in local VM
  38. % called localinstancedict, in which the key is the category name and
  39. % the value is the analogue of Instances for local instances.
  40.  
  41. % We don't currently implement automatic resource unloading.
  42. % When and if we do, it should be hooked to the garbage collector.
  43. % However, Ed Taft of Adobe says their interpreters don't implement this
  44. % either, so we aren't going to worry about it for a while.
  45.  
  46. currentglobal false setglobal systemdict begin
  47.   /localinstancedict 5 dict def
  48. end true setglobal
  49. /.emptydict 0 dict readonly def
  50. setglobal
  51.  
  52. % Resource category dictionaries have the following keys (those marked with
  53. % * are optional):
  54. %    Standard, defined in the Red Book:
  55. %        Category (name)
  56. %        *InstanceType (name)
  57. %        DefineResource
  58. %            <key> <instance> DefineResource <instance>
  59. %        UndefineResource
  60. %            <key> UndefineResource -
  61. %        FindResource
  62. %            <key> FindResource <instance>
  63. %        ResourceStatus
  64. %            <key> ResourceStatus <status> <size> true
  65. %            <key> ResourceStatus false
  66. %        ResourceForAll
  67. %            <template> <proc> <scratch> ResourceForAll -
  68. %        *ResourceFileName
  69. %            <key> <scratch> ResourceFileName <filename>
  70. %    Additional, specific to our implementation:
  71. %        Instances (dictionary)
  72. %        .LocalInstances
  73. %            - .LocalInstances <dict>
  74. %        .GetInstance
  75. %            <key> .GetInstance <instance> -true-
  76. %            <key> .GetInstance -false-
  77. %        .CheckResource
  78. %            <key> <value> .CheckResource <key> <value> <ok>
  79. %              (or may give an error if not OK)
  80. %        .DoLoadResource
  81. %            <key> .DoLoadResource - (may give an error)
  82. %        .LoadResource
  83. %            <key> .LoadResource - (may give an error)
  84. %        .ResourceFile
  85. %            <key> .ResourceFile <file> -true-
  86. %            <key> .ResourceFile <key> -false-
  87. % All the above procedures expect that the top dictionary on the d-stack
  88. % is the resource dictionary.
  89.  
  90. % Define enough of the Category category so we can define other categories.
  91. % The dictionary we're about to create will become the Category
  92. % category definition dictionary.
  93.  
  94. /.findcategory        % <name> .findcategory <category>
  95.  { { /Category findresource } stopped { pop stop } if
  96.  } bind def
  97.  
  98. /.resourceexec        % <key> /xxxResource .resourceexec -
  99.  {            %   (also pops the category from the dstack)
  100.    load stopped { Category end stop } if end
  101.  } bind def
  102.  
  103. 12 dict begin
  104.  
  105.         % Standard entries
  106.  
  107. /Category /Category def
  108. /InstanceType /dicttype def
  109.  
  110. /DefineResource
  111.     { .CheckResource
  112.        { dup /Category 3 index cvlit .growput
  113.         % We would like to make Category dictionaries read-only,
  114.         % and we used to do that here, but we can't do it,
  115.         % because we have to be able to replace the dummy, empty
  116.         % Instances dictionary with the real one later.
  117.          dup [ exch 0 -1 ] exch
  118.          Instances 4 2 roll put
  119.        }
  120.        { /defineresource load /typecheck signalerror
  121.        }
  122.       ifelse
  123.     } bind def
  124. /FindResource        % (redefined below)
  125.     { Instances exch get 0 get
  126.     } bind def
  127.  
  128.         % Additional entries
  129.  
  130. /Instances 25 dict def
  131. Instances /Category [currentdict 0 -1] put
  132.  
  133. /.LocalInstances 0 dict def
  134. /.GetInstance
  135.     { Instances exch .knownget
  136.     } bind def
  137. /.CheckResource
  138.     { dup gcheck currentglobal and
  139.        { /DefineResource /FindResource /ResourceForAll /ResourceStatus
  140.          /UndefineResource }
  141.        { 2 index exch known and }
  142.       forall
  143.       not { /defineresource load /invalidaccess signalerror } if
  144.       true
  145.     } bind def
  146.  
  147. Instances end begin    % for the base case of findresource
  148.  
  149. (END CATEGORY) VMDEBUG
  150.  
  151. % Define the resource operators.  We use the "stack protection" feature of
  152. % odef to make sure the stacks are restored properly on an error.
  153. % This requires that the operators not pop anything from the stack until
  154. % they have executed their logic successfully.  We can't make this
  155. % work for resourceforall, but we can make it work for the others.
  156.  
  157. mark
  158. /defineresource {    % <key> <instance> <category> defineresource <instance>
  159.     3 copy .findcategory dup begin
  160.     /InstanceType known {
  161.       dup type InstanceType ne {
  162.         dup type /packedarraytype eq InstanceType /arraytype eq and
  163.         not { /defineresource load /typecheck signalerror } if
  164.       } if
  165.     } if
  166.     /DefineResource .resourceexec
  167.     4 1 roll pop pop pop
  168. }
  169. /findresource {        % <key> <category> findresource <instance>
  170.     2 copy dup /Category eq
  171.       { pop //Category 0 get } { .findcategory } ifelse
  172.     begin
  173.     /FindResource .resourceexec exch pop exch pop
  174. }
  175. /resourceforall {    % <template> <proc> <scratch> <category> resourceforall -
  176.     .findcategory begin /ResourceForAll .resourceexec
  177. }
  178. /resourcestatus {    % <key> <category> resourcestatus <status> <size> true
  179.             % <key> <category> resourcestatus false
  180.     2 copy .findcategory begin /ResourceStatus .resourceexec
  181.      { 4 2 roll pop pop true } { pop pop false } ifelse
  182. }
  183. /undefineresource {    % <key> <category> undefineresource -
  184.     2 copy .findcategory begin /UndefineResource .resourceexec pop pop
  185. }
  186. end        % Instances of Category
  187. counttomark 2 idiv { bind odef } repeat pop
  188.  
  189. % Define the system parameters used for the Generic implementation of
  190. % ResourceFileName.
  191. systemdict begin
  192. currentdict /systemparams known not { /systemparams 10 dict readonly def } if
  193. systemparams
  194.   dup /FontResourceDir (/Resource/Font/) readonly .forceput
  195.   dup /GenericResourceDir (/Resource/) readonly .forceput
  196.   dup /GenericResourcePathSep (/) readonly .forceput
  197. pop
  198. end
  199.  
  200. % Define the generic algorithm for computing resource file names.
  201. /.rfnstring 100 string def
  202. /.genericrfn        % <key> <scratch> <prefix> .genericrfn <filename>
  203.  { 3 -1 roll //.rfnstring cvs concatstrings exch copy
  204.  } bind def
  205.  
  206. % Define the Generic category.
  207.  
  208. /Generic mark
  209.  
  210.         % Standard entries
  211.  
  212. % We're still running in Level 1 mode, so dictionaries won't expand.
  213. % Leave room for the /Category entry.
  214. /Category null
  215.  
  216. /DefineResource
  217.     { .CheckResource
  218.        { dup [ exch 0 -1 ] exch
  219.          currentglobal
  220.           { false setglobal 2 index UndefineResource    % remove local def if any
  221.         true setglobal
  222.         Instances dup //.emptydict eq
  223.          { pop 3 dict /Instances 1 index def
  224.          }
  225.         if
  226.           }
  227.           { .LocalInstances dup //.emptydict eq
  228.              { pop 3 dict localinstancedict Category 2 index put
  229.          }
  230.         if
  231.           }
  232.          ifelse
  233.          4 2 roll .growput
  234.        }
  235.        { /defineresource load /typecheck signalerror
  236.        }
  237.       ifelse
  238.     } bind
  239. /UndefineResource
  240.     {  { dup 2 index .knownget
  241.           { dup 1 get 1 ge
  242.          { dup 0 null put 1 2 put pop pop }
  243.          { pop exch .undef }
  244.         ifelse
  245.           }
  246.           { pop pop
  247.           }
  248.          ifelse
  249.        }
  250.       currentglobal
  251.        { 2 copy Instances exch exec
  252.        }
  253.       if .LocalInstances exch exec
  254.     } bind
  255. /FindResource
  256.     { dup ResourceStatus
  257.        { pop 1 gt            % not in VM
  258.           { .DoLoadResource
  259.           }
  260.          if
  261.          .GetInstance pop        % can't fail
  262.          0 get
  263.        }
  264.        { /findresource load /undefinedresource signalerror
  265.        }
  266.       ifelse
  267.     } bind
  268. /ResourceStatus
  269.     { dup .GetInstance
  270.        { exch pop dup 1 get exch 2 get true }
  271.        { .ResourceFile
  272.           { closefile 2 -1 true }
  273.           { pop false }
  274.          ifelse
  275.        }
  276.       ifelse
  277.     } bind
  278. /ResourceForAll
  279.     { % **************** Doesn't present instance groups in
  280.       % **************** the correct order yet.
  281.       % We construct a new procedure so we don't have to use
  282.       % static resources to hold the iteration state.
  283.       3 packedarray        % template, proc, scratch
  284.       { exch pop    % stack contains: key, {template, proc, scratch}
  285.         2 copy 0 get .stringmatch
  286.          { 1 index type dup /stringtype eq exch /nametype eq or
  287.         { 2 copy 2 get cvs
  288.           exch 1 get 3 -1 roll pop
  289.         }
  290.         { 1 get
  291.         }
  292.            ifelse exec
  293.          }
  294.          { pop pop
  295.          }
  296.         ifelse
  297.       } /exec cvx 3 packedarray cvx
  298.       % We must pop the resource dictionary off the dict stack
  299.       % when doing the actual iteration, and restore it afterwards.
  300.       currentglobal .LocalInstances length 0 eq or not
  301.        {        % We must do local instances, and do them first.
  302.          /forall cvx 1 index currentdict 3 packedarray cvx
  303.          .LocalInstances 3 1 roll end exec begin
  304.        }
  305.       if
  306.       Instances exch
  307.       /forall cvx currentdict 2 packedarray cvx
  308.       end exec begin
  309.     } bind
  310. /ResourceFileName
  311.     { /GenericResourceDir getsystemparam 
  312.       Category .namestring concatstrings
  313.       /GenericResourcePathSep getsystemparam concatstrings
  314.       .genericrfn
  315.     } bind
  316.  
  317.         % Additional entries
  318.  
  319. % Unfortunately, we can't create the real Instances dictionary now,
  320. % because if someone copies the Generic category (which pp. 95-96 of the
  321. % 2nd Edition Red Book says is legitimate), they'll wind up sharing
  322. % the Instances.  Instead, we have to create Instances on demand,
  323. % just like the entry in localinstancedict.
  324. % We also have to prevent anyone from creating instances of Generic itself.
  325. /Instances //.emptydict
  326.  
  327. /.LocalInstances
  328.     { localinstancedict Category .knownget not { //.emptydict } if
  329.     } bind
  330. /.GetInstance
  331.     { currentglobal
  332.        { Instances exch .knownget }
  333.        { .LocalInstances 1 index .knownget
  334.           { exch pop true }
  335.           { Instances exch .knownget }
  336.          ifelse
  337.        }
  338.       ifelse
  339.     } bind
  340. /.CheckResource
  341.     { true
  342.     } bind
  343. /.DoLoadResource
  344.     { dup vmstatus pop exch pop exch
  345.       .LoadResource
  346.       vmstatus pop exch pop exch sub
  347.       1 index .GetInstance not
  348.        { pop dup /undefinedresource signalerror }    % didn't load
  349.       if
  350.       dup 1 1 put
  351.       2 3 -1 roll put
  352.     } bind
  353. /.LoadResource
  354.     { dup .ResourceFile
  355.        { exch pop currentglobal
  356.           { run }
  357.           { true setglobal { run } stopped false setglobal { stop } if }
  358.          ifelse
  359.        }
  360.        { dup /undefinedresource signalerror
  361.        }
  362.      ifelse
  363.     } bind
  364. /.ResourceFile
  365.     { currentdict /ResourceFileName known
  366.        { mark 1 index 100 string { ResourceFileName }
  367.          .internalstopped
  368.           { cleartomark false }
  369.           { exch pop findlibfile
  370.          { exch pop exch pop true }
  371.          { pop false }
  372.         ifelse
  373.           }
  374.          ifelse
  375.        }
  376.        { false }
  377.       ifelse
  378.     } bind
  379.  
  380. .dicttomark
  381. /Category defineresource pop
  382.  
  383. % Fill in the rest of the Category category.
  384. /Category /Category findresource dup
  385. /Generic /Category findresource begin
  386.  { /FindResource /ResourceForAll /ResourceStatus /UndefineResource /.ResourceFile }
  387.  { dup load put dup } forall
  388. pop readonly pop end
  389.  
  390. (END GENERIC) VMDEBUG
  391.  
  392. % Define the fixed categories.
  393.  
  394. mark
  395.     % Things other than types
  396.  /ColorSpaceFamily
  397.    mark colorspacedict { pop } forall .packtomark
  398.  /Emulator
  399.    mark EMULATORS { cvn } forall .packtomark
  400.  /Filter
  401.    mark filterdict { pop } forall .packtomark
  402.  /IODevice
  403.     % Loop until the .getiodevice gets a rangecheck.
  404.    errordict /rangecheck 2 copy get
  405.    errordict /rangecheck { pop stop } put    % pop the command
  406.    mark 0 { {dup .getiodevice exch 1 add} loop} .internalstopped
  407.    pop pop pop .packtomark
  408.    4 1 roll put
  409.    .clearerror
  410.     % Types
  411.  /setcolorrendering where
  412.   { pop /ColorRenderingType
  413.      {1}
  414.   } if
  415.  /FMapType
  416.    { }    % These must be deferred, because optional features may add some.
  417.  /FontType
  418.    { }    % These must be deferred, because optional features may add some.
  419.  /FormType
  420.    {1}
  421.  /HalftoneType
  422.    {1 2 3 4 5}
  423.  /ImageType
  424.    {1}
  425.  /PatternType
  426.    {1}            % should check for Pattern color space
  427. counttomark 2 idiv
  428.  { mark
  429.  
  430.         % Standard entries
  431.  
  432.         % We'd like to prohibit defineresource,
  433.         % but because optional features may add entries, we can't.
  434.         % We can at least require that the key and value match.
  435.    /DefineResource
  436.     { currentglobal not
  437.        { /defineresource load /invalidaccess signalerror }
  438.        { 2 copy ne
  439.           { /defineresource load /rangecheck signalerror }
  440.           { dup Instances 4 -2 roll .growput }
  441.          ifelse
  442.        }
  443.       ifelse
  444.     } bind
  445.    /UndefineResource
  446.     { /undefineresource load /invalidaccess signalerror } bind
  447.    /FindResource
  448.     { Instances 1 index .knownget
  449.        { exch pop }
  450.        { /findresource load /undefinedresource signalerror }
  451.       ifelse
  452.     } bind
  453.    /ResourceStatus
  454.     { Instances exch known { 0 0 true } { false } ifelse } bind
  455.    /ResourceForAll
  456.     /Generic /Category findresource /ResourceForAll get
  457.  
  458.         % Additional entries
  459.  
  460.    counttomark 2 add -1 roll
  461.    dup length dict dup begin exch { dup def } forall end
  462.         % We'd like to make the Instances readonly here,
  463.         % but because optional features may add entries, we can't.
  464.    /Instances exch
  465.    /.LocalInstances    % used by ResourceForAll
  466.     0 dict def
  467.  
  468.    .dicttomark /Category defineresource pop
  469.  } repeat pop
  470.  
  471. (END FIXED) VMDEBUG
  472.  
  473. % Define the other built-in categories.
  474.  
  475. /.definecategory    % <name> -mark- <key1> ... <valuen> .definecategory -
  476.  { counttomark 2 idiv 2 add        % Instances, Category
  477.    /Generic /Category findresource dup maxlength 3 -1 roll add
  478.    dict .copydict begin
  479.    counttomark 2 idiv { def } repeat pop    % pop the mark
  480.    currentdict end /Category defineresource pop
  481.  } bind def
  482.  
  483. /ColorRendering mark /InstanceType /dicttype .definecategory
  484. /ColorSpace mark /InstanceType /arraytype .definecategory
  485. /Form mark /InstanceType /dicttype .definecategory
  486. /Halftone mark /InstanceType /dicttype .definecategory
  487. /Pattern mark /InstanceType /dicttype .definecategory
  488. /ProcSet mark /InstanceType /dicttype .definecategory
  489.  
  490. (END MISC) VMDEBUG
  491.  
  492. % Define the Encoding category.
  493.  
  494. /Encoding mark
  495.  
  496. /InstanceType /arraytype
  497.  
  498. % Handle already-registered encodings, including lazily loaded encodings
  499. % that aren't loaded yet.
  500.  
  501. /Instances mark
  502.   EncodingDirectory
  503.    { dup length 256 eq { [ exch 0 -1 ] } { pop [null 2 -1] } ifelse
  504.    } forall
  505. .dicttomark
  506.  
  507. /.ResourceFileDict mark
  508.   EncodingDirectory
  509.    { dup length 256 eq { pop pop } { 0 get } ifelse
  510.    } forall
  511. .dicttomark
  512.  
  513. /ResourceFileName
  514.  { .ResourceFileDict 2 index .knownget
  515.     { exch copy exch pop }
  516.     { /Generic /Category findresource /ResourceFileName get exec }
  517.    ifelse
  518.  } bind
  519.  
  520. .definecategory            % Encoding
  521.  
  522. % Make placeholders in level2dict for the redefined Encoding operators,
  523. % so that they will be swapped properly when we switch language levels.
  524.  
  525. /.findencoding /.findencoding load def
  526. /findencoding /findencoding load def
  527. /.defineencoding /.defineencoding load def
  528.  
  529. (END ENCODING) VMDEBUG
  530.  
  531. % Define the Font category.
  532.  
  533. /Font mark
  534.  
  535. /InstanceType /dicttype
  536.  
  537. /DefineResource
  538.     { 2 copy //definefont exch pop
  539.       /Generic /Category findresource /DefineResource get exec
  540.     } bind
  541. /UndefineResource
  542.     { dup //undefinefont
  543.       /Generic /Category findresource /UndefineResource get exec
  544.     } bind
  545. /FindResource
  546.     { dup ResourceStatus
  547.        { pop 1 gt { .loadfont } { .GetInstance pop 0 get } ifelse }
  548.        { .loadfont }
  549.       ifelse
  550.     } bind
  551. /ResourceFileName
  552.     { /FontResourceDir getsystemparam .genericrfn
  553.     } bind
  554.  
  555. /.loadfont
  556.     { dup vmstatus pop exch pop exch
  557.       //findfont exec exch        % findfont is a procedure....
  558.       vmstatus pop exch pop exch sub
  559.         % stack: name font vmused
  560.         % findfont has the prerogative of not calling definefont
  561.         % in certain obscure cases of font substitution.
  562.       2 index .GetInstance
  563.        { dup 1 1 put
  564.          2 3 -1 roll put
  565.        }
  566.        { pop
  567.        }
  568.       ifelse exch pop
  569.     } bind
  570.  
  571. /Instances FontDirectory length 2 mul dict
  572.  
  573. .definecategory            % Font
  574.  
  575. % Redefine font "operators".
  576. /.definefontmap
  577.  { /Font /Category findresource /Instances get
  578.    dup 3 index known
  579.     { pop
  580.     }
  581.     { 2 index
  582.         % Make sure we create the array in global VM.
  583.       .currentglobal true .setglobal
  584.       [null 2 -1] exch .setglobal
  585.       .growput
  586.     }
  587.    ifelse
  588.    //.definefontmap exec
  589.  } bind def
  590.  
  591. % Make sure the old definitions are still in systemdict so that
  592. % they will get bound properly.
  593. systemdict begin
  594.   /.origdefinefont /definefont load def
  595.   /.origundefinefont /undefinefont load def
  596.   /.origfindfont /findfont load def
  597. end
  598. /definefont {
  599.   /Font defineresource
  600. } bind odef
  601. /undefinefont {
  602.   /Font undefineresource
  603. } bind odef
  604. % The Red Book requires that findfont be a procedure, not an operator,
  605. % but it still needs to restore the stacks reliably if it fails.
  606. /.findfontop {
  607.   /Font findresource
  608. } bind odef
  609. /findfont {
  610.   .findfontop
  611. } bind def    % Must be a procedure, not an operator
  612.  
  613. % Remove initialization utilities.
  614. currentdict /.definecategory .undef
  615. currentdict /.emptydict .undef
  616.  
  617. end                % level2dict
  618.  
  619. % Convert deferred resources after we finally switch to Level 2.
  620.  
  621. /.fixresources {
  622.     % Encoding resources
  623.  EncodingDirectory
  624.    { dup length 256 eq
  625.       { /Encoding defineresource pop }
  626.       { pop pop }
  627.      ifelse
  628.    } forall
  629.   /.findencoding { /Encoding findresource } bind def
  630.   /findencoding /.findencoding load odef
  631.   /.defineencoding { /Encoding defineresource pop } bind def
  632.     % ColorRendering resources and ProcSet
  633.   systemdict /ColorRendering .knownget {
  634.     /ColorRendering exch /ProcSet defineresource pop
  635.     systemdict /ColorRendering undef
  636.     /DefaultColorRendering currentcolorrendering /ColorRendering
  637.       defineresource pop
  638.     % FontType and FMapType resources
  639.   buildfontdict { pop dup /FontType defineresource pop } forall
  640.   mark
  641.     buildfontdict 0 known { 2 3 4 5 6 7 8 } if
  642.     buildfontdict 9 known { 9 } if
  643.   counttomark { dup /FMapType defineresource pop } repeat pop
  644.   } if
  645.     % clean up
  646.   systemdict /.fixresources undef
  647. } bind def
  648.